{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mask R-CNN\n",
    "\n",
    "This notebook shows how to train a Mask R-CNN object detection and segementation model on a custom coco-style data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import random\n",
    "import math\n",
    "import re\n",
    "import time\n",
    "import numpy as np\n",
    "import cv2\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "sys.path.insert(0, '../libraries')\n",
    "from mrcnn.config import Config\n",
    "import mrcnn.utils as utils\n",
    "import mrcnn.model as modellib\n",
    "import mrcnn.visualize as visualize\n",
    "from mrcnn.model import log\n",
    "import mcoco.coco as coco\n",
    "import mextra.utils as extra_utils\n",
    "\n",
    "%matplotlib inline\n",
    "%config IPCompleter.greedy=True\n",
    "\n",
    "HOME_DIR = '/home/keras'\n",
    "DATA_DIR = os.path.join(HOME_DIR, \"data/shapes\")\n",
    "WEIGHTS_DIR = os.path.join(HOME_DIR, \"data/weights\")\n",
    "MODEL_DIR = os.path.join(DATA_DIR, \"logs\")\n",
    "\n",
    "# Local path to trained weights file\n",
    "COCO_MODEL_PATH = os.path.join(WEIGHTS_DIR, \"mask_rcnn_coco.h5\")\n",
    "# Download COCO trained weights from Releases if needed\n",
    "if not os.path.exists(COCO_MODEL_PATH):\n",
    "    utils.download_trained_weights(COCO_MODEL_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ax(rows=1, cols=1, size=8):\n",
    "    \"\"\"Return a Matplotlib Axes array to be used in\n",
    "    all visualizations in the notebook. Provide a\n",
    "    central point to control graph sizes.\n",
    "    \n",
    "    Change the default size attribute to control the size\n",
    "    of rendered images\n",
    "    \"\"\"\n",
    "    _, ax = plt.subplots(rows, cols, figsize=(size*cols, size*rows))\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset\n",
    "\n",
    "Organize the dataset using the following structure:\n",
    "\n",
    "```\n",
    "DATA_DIR\n",
    "│\n",
    "└───annotations\n",
    "│   │   instances_<subset><year>.json\n",
    "│   \n",
    "└───<subset><year>\n",
    "    │   image021.jpeg\n",
    "    │   image022.jpeg\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading annotations into memory...\n",
      "Done (t=0.11s)\n",
      "creating index...\n",
      "index created!\n",
      "loading annotations into memory...\n",
      "Done (t=0.00s)\n",
      "creating index...\n",
      "index created!\n",
      "loading annotations into memory...\n",
      "Done (t=0.01s)\n",
      "creating index...\n",
      "index created!\n"
     ]
    }
   ],
   "source": [
    "dataset_train = coco.CocoDataset()\n",
    "dataset_train.load_coco(DATA_DIR, subset=\"shapes_train\", year=\"2018\")\n",
    "dataset_train.prepare()\n",
    "\n",
    "dataset_validate = coco.CocoDataset()\n",
    "dataset_validate.load_coco(DATA_DIR, subset=\"shapes_validate\", year=\"2018\")\n",
    "dataset_validate.prepare()\n",
    "\n",
    "dataset_test = coco.CocoDataset()\n",
    "dataset_test.load_coco(DATA_DIR, subset=\"shapes_test\", year=\"2018\")\n",
    "dataset_test.prepare()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load and display random samples\n",
    "image_ids = np.random.choice(dataset_train.image_ids, 4)\n",
    "for image_id in image_ids:\n",
    "    image = dataset_train.load_image(image_id)\n",
    "    mask, class_ids = dataset_train.load_mask(image_id)\n",
    "    visualize.display_top_masks(image, mask, class_ids, dataset_train.class_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Configurations:\n",
      "BACKBONE                       resnet101\n",
      "BACKBONE_STRIDES               [4, 8, 16, 32, 64]\n",
      "BATCH_SIZE                     1\n",
      "BBOX_STD_DEV                   [0.1 0.1 0.2 0.2]\n",
      "DETECTION_MAX_INSTANCES        100\n",
      "DETECTION_MIN_CONFIDENCE       0.7\n",
      "DETECTION_NMS_THRESHOLD        0.3\n",
      "GPU_COUNT                      1\n",
      "GRADIENT_CLIP_NORM             5.0\n",
      "IMAGES_PER_GPU                 1\n",
      "IMAGE_MAX_DIM                  64\n",
      "IMAGE_META_SIZE                16\n",
      "IMAGE_MIN_DIM                  64\n",
      "IMAGE_MIN_SCALE                0\n",
      "IMAGE_RESIZE_MODE              square\n",
      "IMAGE_SHAPE                    [64 64  3]\n",
      "LEARNING_MOMENTUM              0.9\n",
      "LEARNING_RATE                  0.001\n",
      "LOSS_WEIGHTS                   {'rpn_class_loss': 1.0, 'rpn_bbox_loss': 1.0, 'mrcnn_class_loss': 1.0, 'mrcnn_bbox_loss': 1.0, 'mrcnn_mask_loss': 1.0}\n",
      "MASK_POOL_SIZE                 14\n",
      "MASK_SHAPE                     [28, 28]\n",
      "MAX_GT_INSTANCES               100\n",
      "MEAN_PIXEL                     [123.7 116.8 103.9]\n",
      "MINI_MASK_SHAPE                (56, 56)\n",
      "NAME                           shapes\n",
      "NUM_CLASSES                    4\n",
      "POOL_SIZE                      7\n",
      "POST_NMS_ROIS_INFERENCE        1000\n",
      "POST_NMS_ROIS_TRAINING         2000\n",
      "ROI_POSITIVE_RATIO             0.33\n",
      "RPN_ANCHOR_RATIOS              [0.5, 1, 2]\n",
      "RPN_ANCHOR_SCALES              (4, 8, 16, 32, 64)\n",
      "RPN_ANCHOR_STRIDE              1\n",
      "RPN_BBOX_STD_DEV               [0.1 0.1 0.2 0.2]\n",
      "RPN_NMS_THRESHOLD              0.7\n",
      "RPN_TRAIN_ANCHORS_PER_IMAGE    256\n",
      "STEPS_PER_EPOCH                400\n",
      "TRAIN_BN                       False\n",
      "TRAIN_ROIS_PER_IMAGE           32\n",
      "USE_MINI_MASK                  True\n",
      "USE_RPN_ROIS                   True\n",
      "VALIDATION_STEPS               20.0\n",
      "WEIGHT_DECAY                   0.0001\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "image_size = 64\n",
    "rpn_anchor_template = (1, 2, 4, 8, 16) # anchor sizes in pixels\n",
    "rpn_anchor_scales = tuple(i * (image_size // 16) for i in rpn_anchor_template)\n",
    "\n",
    "class ShapesConfig(Config):\n",
    "    \"\"\"Configuration for training on the shapes dataset.\n",
    "    \"\"\"\n",
    "    NAME = \"shapes\"\n",
    "\n",
    "    # Train on 1 GPU and 2 images per GPU. Put multiple images on each\n",
    "    # GPU if the images are small. Batch size is 2 (GPUs * images/GPU).\n",
    "    GPU_COUNT = 1\n",
    "    IMAGES_PER_GPU = 1\n",
    "\n",
    "    # Number of classes (including background)\n",
    "    NUM_CLASSES = 1 + 3  # background + 3 shapes (triangles, circles, and squares)\n",
    "\n",
    "    # Use smaller images for faster training. \n",
    "    IMAGE_MAX_DIM = image_size\n",
    "    IMAGE_MIN_DIM = image_size\n",
    "    \n",
    "    # Use smaller anchors because our image and objects are small\n",
    "    RPN_ANCHOR_SCALES = rpn_anchor_scales\n",
    "\n",
    "    # Aim to allow ROI sampling to pick 33% positive ROIs.\n",
    "    TRAIN_ROIS_PER_IMAGE = 32\n",
    "\n",
    "    STEPS_PER_EPOCH = 400\n",
    "\n",
    "    VALIDATION_STEPS = STEPS_PER_EPOCH / 20\n",
    "    \n",
    "config = ShapesConfig()\n",
    "config.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = modellib.MaskRCNN(mode=\"training\", config=config, model_dir=MODEL_DIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inititalize_weights_with = \"coco\"  # imagenet, coco, or last\n",
    "\n",
    "if inititalize_weights_with == \"imagenet\":\n",
    "    model.load_weights(model.get_imagenet_weights(), by_name=True)\n",
    "    \n",
    "elif inititalize_weights_with == \"coco\":\n",
    "    model.load_weights(COCO_MODEL_PATH, by_name=True,\n",
    "                       exclude=[\"mrcnn_class_logits\", \"mrcnn_bbox_fc\", \n",
    "                                \"mrcnn_bbox\", \"mrcnn_mask\"])\n",
    "    \n",
    "elif inititalize_weights_with == \"last\":\n",
    "    # Load the last model you trained and continue training\n",
    "    model.load_weights(model.find_last()[1], by_name=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Training\n",
    "\n",
    "Training in two stages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Heads\n",
    "\n",
    "Only the heads. Here we're freezing all the backbone layers and training only the randomly initialized layers (i.e. the ones that we didn't use pre-trained weights from MS COCO). To train only the head layers, pass layers='heads' to the train() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.train(dataset_train, dataset_validate, \n",
    "            learning_rate=config.LEARNING_RATE, \n",
    "            epochs=2,\n",
    "            layers='heads')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fine-tuning\n",
    "\n",
    "Fine-tune all layers. Pass layers=\"all to train all layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.train(dataset_train, dataset_validate, \n",
    "            learning_rate=config.LEARNING_RATE / 10,\n",
    "            epochs=3, # starts from the previous epoch, so only 1 additional is trained \n",
    "            layers=\"all\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/keras/data/shapes/logs/shapes20180508T0105/mask_rcnn_shapes_0002.h5\n",
      "Loading weights from  /home/keras/data/shapes/logs/shapes20180508T0105/mask_rcnn_shapes_0002.h5\n"
     ]
    }
   ],
   "source": [
    "class InferenceConfig(ShapesConfig):\n",
    "    GPU_COUNT = 1\n",
    "    IMAGES_PER_GPU = 1\n",
    "\n",
    "inference_config = InferenceConfig()\n",
    "\n",
    "# Recreate the model in inference mode\n",
    "model = modellib.MaskRCNN(mode=\"inference\", \n",
    "                          config=inference_config,\n",
    "                          model_dir=MODEL_DIR)\n",
    "\n",
    "# Get path to saved weights\n",
    "# Either set a specific path or find last trained weights\n",
    "# model_path = os.path.join(ROOT_DIR, \".h5 file name here\")\n",
    "print(model.find_last()[1])\n",
    "model_path = model.find_last()[1]\n",
    "\n",
    "# Load trained weights (fill in path to trained weights here)\n",
    "assert model_path != \"\", \"Provide path to trained weights\"\n",
    "print(\"Loading weights from \", model_path)\n",
    "model.load_weights(model_path, by_name=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test on a random image from the test set\n",
    "\n",
    "First, show the ground truth of the image, then show detection results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original_image           shape: (64, 64, 3)           min:    0.00000  max:  252.00000  uint8\n",
      "image_meta               shape: (16,)                 min:    0.00000  max:  512.00000  float64\n",
      "gt_class_id              shape: (6,)                  min:    1.00000  max:    3.00000  int32\n",
      "gt_bbox                  shape: (6, 4)                min:    0.00000  max:   64.00000  int32\n",
      "gt_mask                  shape: (64, 64, 6)           min:    0.00000  max:    1.00000  bool\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 1 images\n",
      "image                    shape: (64, 64, 3)           min:    0.00000  max:  252.00000  uint8\n",
      "molded_images            shape: (1, 64, 64, 3)        min: -123.70000  max:  147.10000  float64\n",
      "image_metas              shape: (1, 16)               min:    0.00000  max:   64.00000  int64\n",
      "anchors                  shape: (1, 1023, 4)          min:   -0.71833  max:    0.98140  float32\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_id = random.choice(dataset_test.image_ids)\n",
    "original_image, image_meta, gt_class_id, gt_bbox, gt_mask =\\\n",
    "    modellib.load_image_gt(dataset_test, inference_config, \n",
    "                           image_id, use_mini_mask=False)\n",
    "\n",
    "log(\"original_image\", original_image)\n",
    "log(\"image_meta\", image_meta)\n",
    "log(\"gt_class_id\", gt_class_id)\n",
    "log(\"gt_bbox\", gt_bbox)\n",
    "log(\"gt_mask\", gt_mask)\n",
    "\n",
    "visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id, \n",
    "                            dataset_train.class_names, figsize=(8, 8))\n",
    "\n",
    "results = model.detect([original_image], verbose=1)\n",
    "\n",
    "r = results[0]\n",
    "visualize.display_instances(original_image, r['rois'], r['masks'], r['class_ids'], \n",
    "                            dataset_test.class_names, r['scores'], ax=get_ax())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluation\n",
    "\n",
    "Use the test dataset to evaluate the precision of the model on each class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions =\\\n",
    "extra_utils.compute_multiple_per_class_precision(model, inference_config, dataset_test,\n",
    "                                                 number_of_images=250, iou_threshold=0.5)\n",
    "complete_predictions = []\n",
    "\n",
    "for shape in predictions:\n",
    "    complete_predictions += predictions[shape]\n",
    "    print(\"{} ({}): {}\".format(shape, len(predictions[shape]), np.mean(predictions[shape])))\n",
    "\n",
    "print(\"--------\")\n",
    "print(\"average: {}\".format(np.mean(complete_predictions)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(model.find_last()[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convert result to COCO\n",
    "\n",
    "Converting the result back to a COCO-style format for further processing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading annotations into memory...\n",
      "Done (t=0.00s)\n",
      "creating index...\n",
      "index created!\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import pylab\n",
    "import matplotlib.pyplot as plt\n",
    "from tempfile import NamedTemporaryFile\n",
    "from pycocotools.coco import COCO\n",
    "\n",
    "coco_dict = extra_utils.result_to_coco(results[0], dataset_test.class_names,\n",
    "                                       np.shape(original_image)[0:2], tolerance=0)\n",
    "\n",
    "with NamedTemporaryFile('w') as jsonfile:\n",
    "    json.dump(coco_dict, jsonfile)\n",
    "    jsonfile.flush()\n",
    "    coco_data = COCO(jsonfile.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "category_ids = coco_data.getCatIds(catNms=['square', 'circle', 'triangle'])\n",
    "image_data = coco_data.loadImgs(1)[0]\n",
    "image = original_image\n",
    "plt.imshow(image); plt.axis('off')\n",
    "pylab.rcParams['figure.figsize'] = (8.0, 10.0)\n",
    "annotation_ids = coco_data.getAnnIds(imgIds=image_data['id'], catIds=category_ids, iscrowd=None)\n",
    "annotations = coco_data.loadAnns(annotation_ids)\n",
    "coco_data.showAnns(annotations)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
